home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / fsrmt / fsrmtPipe.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  9KB  |  302 lines
  1. /*
  2.  * fsRmtPipe.c --
  3.  *
  4.  *    Routines for remote unnamed pipes.  An unnamed pipe has a fixed length
  5.  *    resident buffer, a reading stream, and a writing stream.
  6.  *    Process migration can result in remotely accessed pipes.
  7.  *
  8.  * Copyright 1989 Regents of the University of California
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  */
  17.  
  18. #ifndef lint
  19. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/fsrmt/fsrmtPipe.c,v 9.2 92/10/26 14:10:00 mgbaker Exp $ SPRITE (Berkeley)";
  20. #endif not lint
  21.  
  22.  
  23. #include <sprite.h>
  24.  
  25. #include <fs.h>
  26. #include <fsutil.h>
  27. #include <fsconsist.h>
  28. #include <fsio.h>
  29. #include <fsNameOps.h>
  30. #include <fsStat.h>
  31. #include <fsrmt.h>
  32. #include <vm.h>
  33. #include <proc.h>
  34. #include <rpc.h>
  35. #include <fsioPipe.h>
  36. #include <stdio.h>
  37. /*
  38.  * Migration debugging.
  39.  */
  40. #ifdef MIG_DEBUG
  41.  
  42. #define PIPE_CREATED(inStreamPtr, outStreamPtr) \
  43.     { \
  44.     printf("Create Pipe: Srvr %d Read <%d> Write <%d> I/O %d <%d,%d>\n", \
  45.         (inStreamPtr)->hdr.fileID.serverID, \
  46.         (inStreamPtr)->hdr.fileID.minor, \
  47.         (outStreamPtr)->hdr.fileID.minor, \
  48.         (inStreamPtr)->ioHandlePtr->fileID.serverID, \
  49.         (inStreamPtr)->ioHandlePtr->fileID.major, \
  50.         (inStreamPtr)->ioHandlePtr->fileID.minor); \
  51.     }
  52.  
  53. #define PIPE_CLOSE(streamPtr, handlePtr) \
  54.     printf("Pipe Close: Stream %s <%d> I/O <%d,%d> ref %d write %d flags %x\n", \
  55.         ((streamPtr)->flags & FS_READ) ? "Read" : "Write", \
  56.         (streamPtr)->hdr.fileID.minor, \
  57.         (handlePtr)->hdr.fileID.major, (handlePtr)->hdr.fileID.minor, \
  58.         (handlePtr)->use.ref, (handlePtr)->use.write, \
  59.         (handlePtr)->flags)
  60.  
  61. #define PIPE_MIG_1(migInfoPtr, dstClientID) \
  62.     printf("Pipe Migrate: %d => %d Stream %d <%d> I/O <%d,%d> migFlags %x ", \
  63.         (migInfoPtr)->srcClientID, dstClientID, \
  64.         (migInfoPtr)->streamID.serverID, (migInfoPtr)->streamID.minor, \
  65.         (migInfoPtr)->ioFileID.major, (migInfoPtr)->ioFileID.minor, \
  66.         (migInfoPtr)->flags);
  67.  
  68. #define PIPE_MIG_2(migInfoPtr, closeSrcClient, handlePtr) \
  69.     printf("=> %x\n    closeSrc %d (ref %d write %d", (migInfoPtr)->flags, \
  70.         closeSrcClient, (handlePtr)->use.ref, (handlePtr)->use.write);
  71.  
  72. #define PIPE_MIG_3(handlePtr) \
  73.     printf(" | ref %d write %d)\n", \
  74.         (handlePtr)->use.ref, (handlePtr)->use.write);
  75.  
  76. #define PIPE_MIG_END(handlePtr) \
  77.     printf("PipeMigEnd: I/O <%d,%d> ref %d write %d\n", \
  78.         (handlePtr)->hdr.fileID.major, (handlePtr)->hdr.fileID.minor, \
  79.         (handlePtr)->use.ref, (handlePtr)->use.write)
  80. #else
  81.  
  82. #define PIPE_CREATED(inStreamPtr, outStreamPtr)
  83. #define PIPE_CLOSE(streamPtr, handlePtr)
  84. #define PIPE_MIG_1(migInfoPtr, dstClientID)
  85. #define PIPE_MIG_2(migInfoPtr, closeSrcClient, handlePtr)
  86. #define PIPE_MIG_3(handlePtr)
  87. #define PIPE_MIG_END(handlePtr)
  88.  
  89. #endif /* MIG_DEBUG */
  90.  
  91. /*
  92.  * ----------------------------------------------------------------------------
  93.  *
  94.  * FsrmtPipeMigrate --
  95.  *
  96.  *    This takes care of transfering references from one client to the other.
  97.  *    A useful side-effect of this routine is    to properly set the type in
  98.  *    the ioFileID, either FSIO_LCL_PIPE_STREAM or FSIO_RMT_PIPE_STREAM,
  99.  *    so that the subsequent call to Fsrmt_IOMigOpen will set up
  100.  *    the right I/O handle.
  101.  *
  102.  * Results:
  103.  *    An error status if the I/O handle can't be set-up.
  104.  *    Otherwise SUCCESS is returned, *flagsPtr may have the FS_RMT_SHARED
  105.  *    bit set, and *sizePtr and *dataPtr are set to reference Fsio_DeviceState.
  106.  *
  107.  * Side effects:
  108.  *    Sets the correct stream type on the ioFileID.
  109.  *    Shifts client references from the srcClient to the destClient.
  110.  *    Set up and return Fsio_DeviceState for use by the MigEnd routine.
  111.  *
  112.  * ----------------------------------------------------------------------------
  113.  *
  114.  */
  115. /*ARGSUSED*/
  116. ReturnStatus
  117. FsrmtPipeMigrate(migInfoPtr, dstClientID, flagsPtr, offsetPtr, sizePtr, dataPtr)
  118.     Fsio_MigInfo    *migInfoPtr;    /* Migration state */
  119.     int        dstClientID;    /* ID of target client */
  120.     int        *flagsPtr;    /* In/Out Stream usage flags */
  121.     int        *offsetPtr;    /* Return - new stream offset (not needed) */
  122.     int        *sizePtr;    /* Return - sizeof(Fsio_DeviceState) */
  123.     Address    *dataPtr;    /* Return - pointer to Fsio_DeviceState */
  124. {
  125.     register ReturnStatus        status;
  126.  
  127.     if (migInfoPtr->ioFileID.serverID == rpc_SpriteID) {
  128.     /*
  129.      * The pipe was remote, which is why we were called, but is now local.
  130.      */
  131.     migInfoPtr->ioFileID.type = FSIO_LCL_PIPE_STREAM;
  132.     return(Fsio_PipeMigrate(migInfoPtr, dstClientID, flagsPtr, offsetPtr,
  133.         sizePtr, dataPtr));
  134.     }
  135.     migInfoPtr->ioFileID.type = FSIO_RMT_PIPE_STREAM;
  136.     status = Fsrmt_NotifyOfMigration(migInfoPtr, flagsPtr, offsetPtr,
  137.                  0, (Address)NIL);
  138.     if (status != SUCCESS) {
  139.     printf( "FsrmtPipeMigrate, server error <%x>\n",
  140.         status);
  141.     } else {
  142.     *dataPtr = (Address)NIL;
  143.     *sizePtr = 0;
  144.     }
  145.     return(status);
  146. }
  147.  
  148. /*
  149.  *----------------------------------------------------------------------
  150.  *
  151.  * FsrmtPipeVerify --
  152.  *
  153.  *    Verify that the remote client is known for the pipe, and return
  154.  *    a locked pointer to the pipe's I/O handle.
  155.  *
  156.  * Results:
  157.  *    A pointer to the I/O handle for the pipe, or NIL if
  158.  *    the client is bad.
  159.  *
  160.  * Side effects:
  161.  *    The handle is returned locked and with its refCount incremented.
  162.  *    It should be released with Fsutil_HandleRelease.
  163.  *
  164.  *----------------------------------------------------------------------
  165.  */
  166.  
  167. Fs_HandleHeader *
  168. FsrmtPipeVerify(fileIDPtr, clientID, domainTypePtr)
  169.     Fs_FileID    *fileIDPtr;    /* Client's I/O file ID */
  170.     int        clientID;    /* Host ID of the client */
  171.     int        *domainTypePtr;    /* Return - FS_LOCAL_DOMAIN */
  172. {
  173.     register Fsio_PipeIOHandle    *handlePtr;
  174.     register Fsconsist_ClientInfo    *clientPtr;
  175.     Boolean            found = FALSE;
  176.  
  177.     fileIDPtr->type = FSIO_LCL_PIPE_STREAM;
  178.     handlePtr = Fsutil_HandleFetchType(Fsio_PipeIOHandle, fileIDPtr);
  179.     if (handlePtr != (Fsio_PipeIOHandle *)NIL) {
  180.     LIST_FORALL(&handlePtr->clientList, (List_Links *) clientPtr) {
  181.         if (clientPtr->clientID == clientID) {
  182.         found = TRUE;
  183.         break;
  184.         }
  185.     }
  186.     if (!found) {
  187.         Fsutil_HandleRelease(handlePtr, TRUE);
  188.         handlePtr = (Fsio_PipeIOHandle *)NIL;
  189.     }
  190.     }
  191.     if (!found) {
  192.     printf(
  193.         "FsrmtPipeVerify, client %d not known for pipe <%d,%d>\n",
  194.         clientID, fileIDPtr->major, fileIDPtr->minor);
  195.     }
  196.     if (domainTypePtr != (int *)NIL) {
  197.     *domainTypePtr = FS_LOCAL_DOMAIN;
  198.     }
  199.     return((Fs_HandleHeader *)handlePtr);
  200. }
  201.  
  202. /*
  203.  *----------------------------------------------------------------------
  204.  *
  205.  * FsrmtPipeReopen --
  206.  *
  207.  *    Reopen a remote pipe.  This sets up and conducts an 
  208.  *    RPC_FS_REOPEN remote procedure call to re-open the remote pipe.
  209.  *
  210.  * Results:
  211.  *    A  non-SUCCESS return code if the re-open failed.
  212.  *
  213.  * Side effects:
  214.  *    If the reopen works we'll have a valid I/O handle.
  215.  *
  216.  *----------------------------------------------------------------------
  217.  */
  218. /*ARGSUSED*/
  219. ReturnStatus
  220. FsrmtPipeReopen(hdrPtr, clientID, inData, outSizePtr, outDataPtr)
  221.     Fs_HandleHeader    *hdrPtr;
  222.     int            clientID;        /* Should be rpc_SpriteID */
  223.     ClientData        inData;            /* IGNORED */
  224.     int            *outSizePtr;        /* IGNORED */
  225.     ClientData        *outDataPtr;        /* IGNORED */
  226. {
  227.     register Fsrmt_IOHandle    *rmtHandlePtr;
  228.     ReturnStatus        status;
  229.     Fsio_PipeReopenParams        reopenParams;
  230.     int                outSize;
  231.  
  232.     rmtHandlePtr = (Fsrmt_IOHandle *)hdrPtr;
  233.     reopenParams.fileID = hdrPtr->fileID;
  234.     reopenParams.fileID.type = FSIO_LCL_PIPE_STREAM;
  235.     reopenParams.use = rmtHandlePtr->recovery.use;
  236.  
  237.     /*
  238.      * Contact the server to do the reopen, and then notify waiters.
  239.      */
  240.     outSize = 0;
  241.     status = FsrmtReopen(hdrPtr, sizeof(Fsio_PipeReopenParams),
  242.         (Address)&reopenParams, &outSize, (Address)NIL);
  243.     return(status);
  244. }
  245.  
  246. /*
  247.  *----------------------------------------------------------------------
  248.  *
  249.  * FsrmtSetupPipeReopen --
  250.  *
  251.  *    Set up the data for an RPC to reopen a pipe handle.
  252.  *
  253.  * Results:
  254.  *    Return status;
  255.  *
  256.  * Side effects:
  257.  *    Data structure set up.
  258.  *
  259.  *----------------------------------------------------------------------
  260.  */
  261. ReturnStatus
  262. FsrmtSetupPipeReopen(hdrPtr, paramsPtr)
  263.     Fs_HandleHeader        *hdrPtr;
  264.     Address            paramsPtr;
  265. {
  266.     Fsrmt_IOHandle        *rmtHandlePtr;
  267.     Fsio_PipeReopenParams    *reopenParamsPtr;
  268.  
  269.     rmtHandlePtr = (Fsrmt_IOHandle *)hdrPtr;
  270.     reopenParamsPtr = (Fsio_PipeReopenParams *)    paramsPtr;
  271.     reopenParamsPtr->fileID = hdrPtr->fileID;
  272.     reopenParamsPtr->fileID.type = FSIO_LCL_PIPE_STREAM;
  273.     reopenParamsPtr->use = rmtHandlePtr->recovery.use;
  274.  
  275.     return SUCCESS;
  276. }
  277.  
  278. /*
  279.  *----------------------------------------------------------------------
  280.  *
  281.  * FsrmtFinishPipeReopen --
  282.  *
  283.  *    Do post-processing for a file handle after bulk reopen.
  284.  *    There is none for a pipe.
  285.  *
  286.  * Results:
  287.  *    None.
  288.  *
  289.  * Side effects:
  290.  *    None.
  291.  *
  292.  *----------------------------------------------------------------------
  293.  */
  294. void
  295. FsrmtFinishPipeReopen(hdrPtr, statePtr, status)
  296.     Fs_HandleHeader        *hdrPtr;
  297.     Address            statePtr;
  298.     ReturnStatus        status;
  299. {
  300.     return;
  301. }
  302.